Micron Document
<!DOCTYPE html>
<html class="client-nojs vector-feature-language-in-header-enabled vector-feature-language-in-main-page-header-disabled vector-feature-page-tools-pinned-disabled vector-feature-toc-pinned-clientpref-0 vector-toc-not-available vector-feature-main-menu-pinned-disabled vector-feature-limited-width-clientpref-1 vector-feature-limited-width-content-enabled vector-feature-custom-font-size-clientpref-1 vector-feature-appearance-pinned-clientpref-0 skin-theme-clientpref-day vector-sticky-header-enabled" lang="de" dir="ltr"><head>
<meta charset="UTF-8">
<title>X10 (Programmiersprache)</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" type="image/png" href="./_res_/favicon.png">
<link rel="canonical" href="https://de.wikipedia.org/wiki/X10_(Programmiersprache)"> <link href="./_mw_/ext.cite.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.pygments.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.wikimediamessages.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.icons.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.search.codex.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.styles.css" rel="stylesheet" type="text/css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link href="./_mw_/ext.gadget.citeRef.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.defaultPlainlinks.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonHide.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonLayout.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonStyle.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiDarkmode.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiResponsive.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.specialSearch.css" rel="stylesheet" type="text/css">
<link rel="stylesheet" type="text/css" href="./_mw_/site.styles.css">
<link rel="stylesheet" type="text/css" href="./_mw_/noscript.css">
<link rel="stylesheet" type="text/css" href="./_res_/footer.css">
<link rel="stylesheet" type="text/css" href="./_res_/vector-2022.css">
</head>
<body class="skin--responsive skin-vector skin-vector-search-vue mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-X10_Programmiersprache rootpage-X10_Programmiersprache skin-vector-2022 action-view">
<div class="mw-page-container">
<div class="mw-page-container-inner">
<div class="mw-content-container">
<main id="content" class="mw-body">
<header class="mw-body-header vector-page-titlebar">
<h1 id="firstHeading" class="firstHeading mw-first-heading"><span class="mw-page-title-main">X10 (Programmiersprache)</span></h1>
</header>
<a id="top"></a>
<div id="bodyContent" class="vector-body ve-init-mw-desktopArticleTarget-targetContainer" aria-labelledby="firstHeading" data-mw-ve-target-container="">
<div id="contentSub">
<div id="mw-content-subtitle"></div>
</div>
<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="de" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="de" dir="ltr"><table class="float-right infobox toccolours toptextcells" style="font-size:90%; margin-top:0; width:21em;">

<tbody><tr>
<th colspan="2" class="hintergrundfarbe6" style="font-size:larger;">X10
</th></tr>




<tr>
<th colspan="2" class="hintergrundfarbe5" style="font-size:105%; text-align:center;">Basisdaten
</th></tr>
<tr>
<td><b><a href="Programmierparadigma" title="Programmierparadigma">Paradigmen</a>:</b>
</td>
<td><a href="Objektorientierte_Programmierung" title="Objektorientierte Programmierung">Objektorientierte Programmiersprache</a>
</td></tr>
<tr>
<td><b>Erscheinungsjahr:</b>
</td>
<td>2004
</td></tr>

<tr>
<td><b>Designer:</b>
</td>
<td><span class="wikidata-content">Kemal Ebcioğlu, Vivek Sarkar, Vijay Saraswat</span>
</td></tr>
<tr>
<td><b>Entwickler:</b>
</td>
<td>Kemal Ebcioğlu, Vijay Saraswat und Vivek Sarkar (<a href="IBM" title="IBM">IBM</a>)
</td></tr>
<tr>
<td><b>Aktuelle&nbsp;<a href="Version_(Software)" title="Version (Software)">Version</a>:</b>
</td>
<td style="white-space:nowrap;">2.6.2<sup id="cite_ref-Spec_1-0" class="reference"><a href="#cite_note-Spec-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup> &nbsp;<small>(8. Januar 2019)</small>
</td></tr>


<tr>
<td><b><a href="Typisierung_(Informatik)" title="Typisierung (Informatik)">Typisierung</a>:</b>
</td>
<td><a href="Starke_Typisierung" title="Starke Typisierung">stark</a>, <a href="Statische_Typisierung" title="Statische Typisierung">statisch</a>
</td></tr>






<tr>
<td><b>Beeinflusst von:</b>
</td>
<td><a href="Java_(Programmiersprache)" title="Java (Programmiersprache)">Java</a>, <a href="C%2B%2B" title="C++">C++</a>, <a href="Scala_(Programmiersprache)" title="Scala (Programmiersprache)">Scala</a>
</td></tr>


<tr>
<td><b><a href="Betriebssystem" title="Betriebssystem">Betriebssystem</a>:</b>
</td>
<td><a href="AIX" title="AIX">AIX</a>, <a href="Linux" title="Linux">Linux</a>, <a href="MacOS" title="MacOS">macOS</a>, <a href="Windows" class="mw-redirect" title="Windows">Windows</a>/<a href="Cygwin" title="Cygwin">Cygwin</a>
</td></tr>
<tr>
<td><b><a href="Lizenz" title="Lizenz">Lizenz</a>:</b>
</td>
<td><a href="Eclipse_Public_License" title="Eclipse Public License">Eclipse Public License</a> 1.0
</td></tr>
<tr>
<td colspan="2" class="hintergrundfarbe5" style="text-align:center;"><a rel="nofollow" class="external free" href="http://x10-lang.org/">http://x10-lang.org/</a>
</td></tr></tbody></table>
<p><b>X10</b> ist eine <a href="Parallele_Programmierung" title="Parallele Programmierung">parallele</a>, <a href="Objektorientierung" title="Objektorientierung">objektorientierte</a> <a href="Programmiersprache" title="Programmiersprache">Programmiersprache</a>, für high-end Hardware mit bis zu 10000 Hardware-<a href="Thread_(Informatik)" title="Thread (Informatik)">Threads</a><sup id="cite_ref-Spec_1-1" class="reference"><a href="#cite_note-Spec-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup>. Sie wurde 2004 bei <a href="IBM" title="IBM">IBM</a> am <a href="Thomas_J._Watson_Research_Center" title="Thomas J. Watson Research Center">Forschungszentrum Thomas J. Watson</a> als Teil des PERCS-Projekts entwickelt. Zielplattformen der Programmiersprache sind Cluster-Systeme mit unterschiedlichen Berechnungseinheiten (Non-Uniform Cluster Computing). Die Programmiererproduktivität solcher Systeme soll mit X10 um den Faktor zehn erhöht werden, was zu dem Namen X10 geführt hat.<sup id="cite_ref-2" class="reference"><a href="#cite_note-2"><span class="cite-bracket">[</span>2<span class="cite-bracket">]</span></a></sup> Die Entwicklung von X10 wurde durch das High Productivity Computing Systems (HPCS) Programm der <a href="DARPA" class="mw-redirect" title="DARPA">DARPA</a> finanziert.
</p><p>X10 wurde speziell zur parallelen Programmierung nach dem <a href="PGAS" class="mw-redirect" title="PGAS">Partitioned Global Address Space</a> (PGAS) Modell entworfen. X10 erweitert dieses sogar noch um <a href="Asynchronit%C3%A4t" class="mw-redirect" title="Asynchronität">Asynchronität</a>, was zu einem APGAS Modell führt. Eine Berechnung ist auf verschiedene Places aufgeteilt. Diese enthalten Daten und eine oder mehrere Activities, die mit diesen Daten arbeiten. X10 hat ein beschränktes Typsystem für <a href="Objektorientierte_Programmierung" title="Objektorientierte Programmierung">objektorientierte Programmierung</a>. Außerdem hat es noch andere Eigenschaften wie benutzerdefinierte primitive <i>struct</i>-Typen, global verteilte <a href="Feld_(Datentyp)" class="mw-redirect" title="Feld (Datentyp)">Arrays</a> und strukturierten und unstrukturierten Parallelismus.<sup id="cite_ref-Spec_1-2" class="reference"><a href="#cite_note-Spec-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup>
</p>

<div class="mw-heading mw-heading2"><h2 id="Grundkonzepte">Grundkonzepte</h2></div>
<div class="mw-heading mw-heading3"><h3 id="Activities">Activities</h3></div>
<p>Eine Activity ist ein leichtgewichtiger Thread ohne eigenen Namen. Asynchrone Activities werden durch den Befehl
</p>
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><span></span><span class="n">at</span><span class="w"> </span><span class="p">(</span><span class="n">p</span><span class="p">)</span><span class="w"> </span><span class="n">async</span><span class="w"> </span><span class="n">s</span>
</pre></div>
<p>erstellt. Dabei ist <i>p</i> der Place, an dem die Activity ausgeführt werden soll und <i>s</i> der Befehl (engl. Statement). Eine Aktivität wird an einem bestimmten Place erstellt und bleibt dort für die gesamte Lebensdauer. Mit dem Schlüsselwort <i>here</i> kann eine Aktivität auf ihren Place zugreifen.<sup id="cite_ref-Saraswat2005_3-0" class="reference"><a href="#cite_note-Saraswat2005-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading3"><h3 id="Places">Places</h3></div>
<p>Ein Place enthält Daten und Activities, die auf diesen Daten arbeiten. Man kann sich einen Place als eigenen Knoten einer verteilten <a href="Java_Virtual_Machine" title="Java Virtual Machine">Java Virtual Machine</a> (JVM) mit eigenem <a href="Dynamischer_Speicher" title="Dynamischer Speicher">Heap</a> und eigenen <a href="Thread_(Informatik)" title="Thread (Informatik)">Threads</a> vorstellen. Dabei kann angenommen werden, dass alle Places geordnet sind. Handelt es sich bei <i>p</i> um einen Place, so kann mit <i>p.next</i> auf den nächsten Place zugegriffen werden.<sup id="cite_ref-Saraswat2005_3-1" class="reference"><a href="#cite_note-Saraswat2005-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup>
</p><p>Es gibt keinen expliziten Befehl um einen neuen Place zu erzeugen, vielmehr wird jede Activity mit einer expliziten Anzahl Places gestartet. Daraus ergibt sich eine fixe Anzahl von Places für das gesamte Programm, die während der gesamten Programmlaufzeit konstant bleibt. Die Places des Programms sind von <i>0</i> bis <i>Place.MAX_PLACES-1</i> nummeriert und werden in einer sortierten Sequenz von <i>Place.places()</i> gespeichert. Auf den Place der aktuellen Activity kann mit dem Schlüsselwort <i>here</i> zugegriffen werden.<sup id="cite_ref-Spec_1-3" class="reference"><a href="#cite_note-Spec-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup>
</p><p>Der Zugriff abhängig vom Place wird durch das statische Feld <i>location</i>, das jedes Objekt enthält, geregelt. Nur die Objekte eines Places erhalten Zugriff auf nicht-finale Felder der anderen Objekte dieses Places. Versuche auf nicht-finale Felder von Objekten auf einem anderen Place zuzugreifen scheitern mit einer <i>BadPlaceException (BPE)</i>.<sup id="cite_ref-Saraswat2005_3-2" class="reference"><a href="#cite_note-Saraswat2005-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup> Man kann jedoch mit dem Ausdruck <i>at</i> einzelne Activitys synchron auf andere Places verschieben. Dabei handelt es sich, wie bei jeder verteilten Operation, um eine sehr teure Operation. Sie bildet jedoch die Grundlage für <a href="Mehrkernprozessor" title="Mehrkernprozessor">Multicore</a> Programmierung in X10.<sup id="cite_ref-Spec_1-4" class="reference"><a href="#cite_note-Spec-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup>
</p><p>Objekte werden auf dem Place erzeugt, auf dem der Konstruktor-Aufruf läuft. Anschließend kann ein Objekt, im Gegensatz zu Activities, nicht mehr den Place wechseln. Es kann nur auf einen anderen Place kopiert oder über <i>GlobalRef</i> von anderen Places referenziert werden.<sup id="cite_ref-Spec_1-5" class="reference"><a href="#cite_note-Spec-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading3"><h3 id="Distributions_und_distributed_Arrays">Distributions und distributed Arrays</h3></div>
<p>Mit Distributions werden distributed Arrays auf Places verteilt. Dabei ist die Distribution ein Objekt, die jedem Element des Arrays einen Place zuordnet. Auf welchem Place ein Element eines distributed Arrays liegen soll, muss bereits zur Array-Erstellung bekannt sein. Dabei ist zu beachten, dass auf einem Place nur auf diejenigen Elemente des distributed Arrays zugegriffen werden kann, die auch auf diesem Place liegen.<sup id="cite_ref-Saraswat2005_3-3" class="reference"><a href="#cite_note-Saraswat2005-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading3"><h3 id="Atomarität"><span id="Atomarit.C3.A4t"></span>Atomarität</h3></div>
<p>Wie in vielen anderen Programmiersprachen verbergen sich hinter einfachen Befehlen, wie dem <a href="Inkrement" class="mw-redirect" title="Inkrement">Inkrement</a> mehrere Maschinenbefehle, was diese zu einem <a href="Kritischer_Abschnitt" title="Kritischer Abschnitt">kritischen Abschnitt</a> macht. Das bedeutet, dass ein solcher Befehl potentiell von einem parallel ausgeführten anderen Befehl unterbrochen werden kann. Um das zu verhindern können in X10 einzelne Befehle mit einem
</p>
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><span></span><span class="n">when</span><span class="p">(</span><span class="n">c</span><span class="p">)</span><span class="w"> </span><span class="n">S</span>
</pre></div>
<p>umgeben werden. Dabei ist <i>c</i> die <a href="Boolesche_Variable" class="mw-redirect" title="Boolesche Variable">boolesche</a> Wächterbedingung und <i>S</i> der atomar auszuführende Befehl (engl. <i>statement</i>). Solange <i>c</i> nicht true ist, blockiert die Ausführung. Wenn <i>c</i> true wird, so wird <i>S</i> atomar ausgeführt.<sup id="cite_ref-Saraswat2005_3-4" class="reference"><a href="#cite_note-Saraswat2005-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup>
</p><p>Um ganze Methoden atomar auszuführen, kann man das Schlüsselwort <i>atomic</i> davor schreiben. Die Methode <i>increment</i> wird beispielsweise atomar ausgeführt<sup id="cite_ref-Saraswat2005_3-5" class="reference"><a href="#cite_note-Saraswat2005-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup>:
</p>
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><span></span><span class="n">atomic</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">increment</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">value</span><span class="o">++</span><span class="p">;</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="kc">true</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Clocks">Clocks</h3></div>
<p>Viele parallele <a href="Algorithmus" title="Algorithmus">Algorithmen</a> sind in verschiedene Phasen aufgeteilt, dabei müssen alle Aktivitäten einer Phase abgearbeitet werden, bevor die nächste Phase beginnt. In X10 werden diese Phasen durch sogenannte <i>Clocks</i> getrennt. Um eine Aktivität an einen solchen Clock zu binden, definiert man diese als <i>clocked()</i> mit dem entsprechenden Clock Objekt.<sup id="cite_ref-Spec_1-6" class="reference"><a href="#cite_note-Spec-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup>
</p><p>Im folgenden Beispiel werden zwei Aktivitäten <i>A</i> und <i>B</i> durch ein Clock Objekt synchronisiert, so dass zuerst die Ausgaben der ersten Phase beider Aktivitäten ausgegeben werden und anschließend die Ausgaben der zweiten Phase beider Aktivitäten<sup id="cite_ref-4" class="reference"><a href="#cite_note-4"><span class="cite-bracket">[</span>Anmerkung 1<span class="cite-bracket">]</span></a></sup>:
</p>
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><span></span><span class="c1">//erzeuge ein Clock Objekt</span>
<span class="n">val</span><span class="w"> </span><span class="n">clock</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Clock</span><span class="p">.</span><span class="na">make</span><span class="p">();</span>

<span class="c1">//erzeuge Aktivität A und binde sie an clock</span>
<span class="n">async</span><span class="w"> </span><span class="nf">clocked</span><span class="p">(</span><span class="n">clock</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="c1">//gebe parallel zu B Text aus</span>
<span class="w"> </span><span class="n">print</span><span class="p">(</span><span class="s">"A: 1st phase. "</span><span class="p">);</span>
<span class="w"> </span><span class="c1">//warte auf B</span>
<span class="w"> </span><span class="n">Clock</span><span class="p">.</span><span class="na">advanceAll</span><span class="p">();</span>
<span class="w"> </span><span class="n">print</span><span class="p">(</span><span class="s">"A: 2nd phase. "</span><span class="p">);</span>
<span class="p">}</span>

<span class="c1">//erzeuge Aktivität B und binde sie an clock</span>
<span class="n">async</span><span class="w"> </span><span class="nf">clocked</span><span class="p">(</span><span class="n">clock</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="c1">//gebe parallel zu A Text aus</span>
<span class="w"> </span><span class="n">print</span><span class="p">(</span><span class="s">"B: 1st phase. "</span><span class="p">);</span>
<span class="w"> </span><span class="c1">//warte auf A</span>
<span class="w"> </span><span class="n">Clock</span><span class="p">.</span><span class="na">advanceAll</span><span class="p">();</span>
<span class="w"> </span><span class="n">print</span><span class="p">(</span><span class="s">"B: 2nd phase. "</span><span class="p">);</span>
<span class="p">}</span>
</pre></div>
<p>Ein mögliches Ergebnis des Beispiels wäre:
</p><p><i>A: 1st phase. B: 1st phase. B: 2nd phase. A: 2nd phase. </i>,
</p><p>nicht aber
</p><p><i>A: 1st phase. A: 2nd phase. B: 1st phase. B: 2nd phase. </i>.
</p>
<div class="mw-heading mw-heading2"><h2 id="Klassen">Klassen</h2></div>
<p>Eine <a href="Klasse_(Objektorientierung)" title="Klasse (Objektorientierung)">Klasse</a> enthält, analog zu Java, Daten und Code. Eine Klasse kann verschiedene Felder, Eigenschaften, <a href="Methode_(Programmierung)" title="Methode (Programmierung)">Methoden</a>, <a href="Konstruktoren_und_Destruktoren" title="Konstruktoren und Destruktoren">Konstruktoren</a> enthalten. Außerdem spezifiziert eine Klasse maximal eine oder keine Elternklasse. Eine Klasse kann mehrere <a href="Schnittstelle#Softwareschnittstelle" title="Schnittstelle">Interfaces</a> implementieren.
</p><p>Eine Klasse kann als <i>final</i> markiert werden. Von einer solchen Klasse kann nicht mehr <a href="Vererbung_(Programmierung)" title="Vererbung (Programmierung)">geerbt</a> werden.
</p>
<div class="mw-heading mw-heading3"><h3 id="Felder">Felder</h3></div>
<p>Felder spezifizieren Daten, die zu einer Klasse gehören. Dabei unterscheidet man, ob die Felder veränderbar (gekennzeichnet mit dem Schlüsselwort <i>var</i>), oder unveränderbar (gekennzeichnet mit dem Schlüsselwort <i>val</i>) sind. Der Typ eines veränderbaren Feldes muss immer spezifiziert werden. Dieser folgt dem Namen der Variable nach einem Doppelpunkt. Unveränderbare Felder können bereits mit einem Wert initialisiert werden, müssen es aber nicht.
</p>
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><span></span><span class="c1">//veränderbares Feld mit dem Namen "population", vom Typ Integer und mit dem initialen Wert 42</span>
<span class="kd">var</span><span class="w"> </span><span class="n">population</span><span class="p">:</span><span class="n">Int</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">42</span><span class="p">;</span>
<span class="c1">//veränderbares Feld mit dem Namen "growthRate", vom Typ Integer und ohne initialen Wert</span>
<span class="kd">var</span><span class="w"> </span><span class="n">growthRate</span><span class="p">:</span><span class="n">Int</span><span class="p">;</span>
</pre></div>
<p>Der Typ eines unveränderbaren Feldes muss nicht explizit angegeben werden. Er kann auch implizit aus dem Initialisierungswert abgeleitet werden. Ein unveränderbares Feld muss nicht initialisiert werden, solange es im Konstruktor der Klasse initialisiert wird.
</p>
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><span></span><span class="c1">//unveränderbares Feld mit dem Namen "pi", vom expliziten Typ Double und ohne initialen Wert</span>
<span class="n">val</span><span class="w"> </span><span class="n">pi</span><span class="p">:</span><span class="n">Double</span><span class="p">;</span>
<span class="c1">//unveränderbares Feld mit dem Namen "truth", vom impliziten Typ Integer und mit initialem Wert 42</span>
<span class="n">val</span><span class="w"> </span><span class="n">truth</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">42</span><span class="p">;</span>
</pre></div>
<p>Felder können entweder objektspezifisch oder <a href="Static_(Schl%C3%BCsselwort)" title="Static (Schlüsselwort)">statisch</a> (mit dem Schlüsselwort <i>static</i> gekennzeichnet) sein. Standardmäßig sind Felder objektspezifisch, das heißt jedes Objekt hat seine eigene Instanz des Feldes. Ist ein Feld statisch, so gibt es für alle Objekte nur eine Instanz dieses Feldes. In X10 müssen statische Variablen immer unveränderbar sein.
</p>
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><span></span><span class="c1">//statisches, unveränderbares Feld mit dem Namen "pi", vom impliziten Typ Double und mit initialem Wert</span>
<span class="kd">static</span><span class="w"> </span><span class="n">val</span><span class="w"> </span><span class="n">pi</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">3</span><span class="p">,</span><span class="mi">141</span><span class="p">;</span>
<span class="c1">//objektspezifisches, unveränderbares Feld mit dem Namen "truth", vom impliziten Typ Integer und mit initialem Wert</span>
<span class="n">val</span><span class="w"> </span><span class="n">truth</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">42</span><span class="p">;</span>
</pre></div>
<div class="mw-heading mw-heading2"><h2 id="Implementierungen">Implementierungen</h2></div>
<p>Es gibt zwei Implementierungen von X10: <i>Native X10</i> und <i>Managed X10</i>. Native X10 basiert auf C++ und bildet einen Place auf einen <a href="Prozess_(Informatik)" title="Prozess (Informatik)">Prozess</a> ab. Es ist für folgende Betriebssysteme verfügbar: <a href="Linux" title="Linux">Linux</a>, <a href="AIX" title="AIX">AIX</a>, <a href="Mac_OS" class="mw-redirect" title="Mac OS">Mac OS</a>, <a href="Cygwin" title="Cygwin">Cygwin</a> und <a href="Blue_Gene" title="Blue Gene">Blue Gene</a>. Managed X10 ist JVM basiert. Es bildet einen Place auf einen JVM-Prozess ab. Da es auf Java basiert, läuft es unabhängig vom Betriebssystem mit jeder Version ab Java 6.<sup id="cite_ref-X10Tut_5-0" class="reference"><a href="#cite_note-X10Tut-5"><span class="cite-bracket">[</span>4<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading2"><h2 id="Einzelnachweise">Einzelnachweise</h2></div>
<ol class="references">
<li id="cite_note-Spec-1"><span class="mw-cite-backlink">↑ <sup><a href="#cite_ref-Spec_1-0">a</a></sup> <sup><a href="#cite_ref-Spec_1-1">b</a></sup> <sup><a href="#cite_ref-Spec_1-2">c</a></sup> <sup><a href="#cite_ref-Spec_1-3">d</a></sup> <sup><a href="#cite_ref-Spec_1-4">e</a></sup> <sup><a href="#cite_ref-Spec_1-5">f</a></sup> <sup><a href="#cite_ref-Spec_1-6">g</a></sup></span> <span class="reference-text">Vijay Saraswat, Bard Bloom, Igor Peshansky, Olivier Tardieu, David Grove,: <cite style="font-style:italic">X10 Language Specification Version 2.6.2</cite>. 2019, <span style="white-space:nowrap">S.<span style="display:inline-block;width:.2em">&nbsp;</span>1–303</span> (<a rel="nofollow" class="external text" href="http://x10.sourceforge.net/documentation/languagespec/x10-262.pdf">sourceforge.net</a> [PDF; <span style="white-space:nowrap">1,5<span style="display:inline-block;width:.2em">&nbsp;</span>MB</span>; abgerufen am 4.&nbsp;Januar 2019]).<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rfr_id=info:sid/de.wikipedia.org:X10+%28Programmiersprache%29&amp;rft.au=Vijay+Saraswat%2C+Bard+Bloom%2C+Igor+Peshansky%2C+...&amp;rft.btitle=X10+Language+Specification+Version+2.6.2&amp;rft.date=2019&amp;rft.genre=book&amp;rft.pages=1-303" style="display:none">&nbsp;</span></span>
</li>
<li id="cite_note-2"><span class="mw-cite-backlink"><a href="#cite_ref-2">↑</a></span> <span class="reference-text">Philippe Charles, Christian Grothoff, Vijay A. Saraswat et al.: <cite style="font-style:italic">X10: An Object-Oriented Approach to Non-Uniform Cluster Computing</cite>. In: <cite style="font-style:italic">OOPSLA</cite>. 2005, <span style="white-space:nowrap">S.<span style="display:inline-block;width:.2em">&nbsp;</span>519–538</span>, <a href="Digital_Object_Identifier" title="Digital Object Identifier">doi</a>:<span class="uri-handle" style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://doi.org/10.1145/1094811.1094852">10.1145/1094811.1094852</a></span>.<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rfr_id=info:sid/de.wikipedia.org:X10+%28Programmiersprache%29&amp;rft.atitle=X10%3A+An+Object-Oriented+Approach+to+Non-Uniform+Cluster+Computing&amp;rft.au=Philippe+Charles%2C+Christian+Grothoff%2C+Vijay+A.+Saraswat+et+al.&amp;rft.btitle=OOPSLA&amp;rft.date=2005&amp;rft.doi=10.1145%2F1094811.1094852&amp;rft.genre=book&amp;rft.pages=519-538" style="display:none">&nbsp;</span></span>
</li>
<li id="cite_note-Saraswat2005-3"><span class="mw-cite-backlink">↑ <sup><a href="#cite_ref-Saraswat2005_3-0">a</a></sup> <sup><a href="#cite_ref-Saraswat2005_3-1">b</a></sup> <sup><a href="#cite_ref-Saraswat2005_3-2">c</a></sup> <sup><a href="#cite_ref-Saraswat2005_3-3">d</a></sup> <sup><a href="#cite_ref-Saraswat2005_3-4">e</a></sup> <sup><a href="#cite_ref-Saraswat2005_3-5">f</a></sup></span> <span class="reference-text">Vijay Saraswat, Radha Jagadeesan: <cite style="font-style:italic">Concurrent Clustered Programming</cite>. In: <cite style="font-style:italic">Lecture Notes in Computer Science</cite>. <span style="white-space:nowrap">Band<span style="display:inline-block;width:.2em">&nbsp;</span>3653</span>. Springer, Berlin Heidelberg 2005, <span style="white-space:nowrap">S.<span style="display:inline-block;width:.2em">&nbsp;</span>353–367</span>, <a href="Digital_Object_Identifier" title="Digital Object Identifier">doi</a>:<span class="uri-handle" style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://doi.org/10.1007/11539452_28">10.1007/11539452_28</a></span>.<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rfr_id=info:sid/de.wikipedia.org:X10+%28Programmiersprache%29&amp;rft.atitle=Concurrent+Clustered+Programming&amp;rft.au=Vijay+Saraswat%2C+Radha+Jagadeesan&amp;rft.btitle=Lecture+Notes+in+Computer+Science&amp;rft.date=2005&amp;rft.doi=10.1007%2F11539452_28&amp;rft.genre=book&amp;rft.pages=353-367&amp;rft.place=Berlin+Heidelberg&amp;rft.pub=Springer&amp;rft.volume=3653" style="display:none">&nbsp;</span></span>
</li>
<li id="cite_note-X10Tut-5"><span class="mw-cite-backlink"><a href="#cite_ref-X10Tut_5-0">↑</a></span> <span class="reference-text">David Grove, Vijay Saraswat, Olivier Tardieu: <cite style="font-style:italic">Developing Scalable Parallel Applications in X10</cite>. 2012, <span style="white-space:nowrap">S.<span style="display:inline-block;width:.2em">&nbsp;</span>1–85</span> (<a rel="nofollow" class="external text" href="http://x10.sourceforge.net/tutorials/x10-2.2/SC_2012/SC12_X10_Tutorial.pdf">online</a> [PDF; <span style="white-space:nowrap">1,3<span style="display:inline-block;width:.2em">&nbsp;</span>MB</span>; abgerufen am 26.&nbsp;August 2013]).<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rfr_id=info:sid/de.wikipedia.org:X10+%28Programmiersprache%29&amp;rft.au=David+Grove%2C+Vijay+Saraswat%2C+Olivier+Tardieu&amp;rft.btitle=Developing+Scalable+Parallel+Applications+in+X10&amp;rft.date=2012&amp;rft.genre=book&amp;rft.pages=1-85" style="display:none">&nbsp;</span></span>
</li>
</ol>
<div class="mw-heading mw-heading2"><h2 id="Anmerkungen">Anmerkungen</h2></div>
<ol class="references" data-mw-group="Anmerkung">
<li id="cite_note-4"><span class="mw-cite-backlink"><a href="#cite_ref-4">↑</a></span> <span class="reference-text">Aktivitäten haben in X10 keine Namen, im Beispiel werden die Aktivitäten nur aus didaktischen Gründen benannt.</span>
</li>
</ol>
<div class="mw-heading mw-heading2"><h2 id="Weblinks">Weblinks</h2></div>
<ul><li><a rel="nofollow" class="external text" href="http://x10-lang.org/">X10 Website</a></li></ul></div><!--htdig_noindex--><div><div class="zim-footer">
Dieser Artikel wurde von <a class="external text" title="Zuletzt bearbeitet am 2024-12-04" href="https://de.wikipedia.org/wiki/?title=X10_(Programmiersprache)&amp;oldid=250948082">Wikipedia</a> herausgegeben. Der Text ist unter <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.de">Creative Commons Attribution-Share Alike 4.0</a> verfügbar, sofern nicht anders angegeben. Für die Mediendateien können zusätzliche Bedingungen gelten.
</div>
</div><!--/htdig_noindex--></div>
</div>
</main>
</div>
</div>
</div>
<script src="./_webp_/webpHandler.js"></script>

</body></html>